.TITLE	DQDRV
	.IDENT	/04.07/
 
;
; Copyright (c) 1995-1999 by Mentec, Inc., U.S.A.
; All rights reserved
;
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED
; OR COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
; VERSION 04.07
;
; P. J. BEZEREDI   01-NOV-77
;
; PREVIOUSLY MODIFIED BY:
;
;	P. J. BEZEREDI
;
; MODIFIED BY:
;
;	P. J. BEZEREDI 06-DEC-79
;
;		PB144 -- RETURN IE.BBE IF MANUFACTURER BAD HEADER
;			IS DETECTED.
;
;	R. T. PERRON 12-DEC-79
;
;		RP026 -- CORRECT MULTI-CONTROLLER OPERATION.
;
;	R. T. PERRON 16-OCT-80
;
;		RP040 -- CORRECT SEEK ERROR RECOVERY ALGORITHM.
;
;	P. J. BEZEREDI 18-MAR-81
;
;		PB228 -- ADD SUPPORT FOR RLV12 CONTROLLER.
;
;	P. J. BEZEREDI 08-APR-81
;
;		PB232 -- RESTORE SCB ADDRESS AFTER CALL TO $FORK.
;
;	P. J. BEZEREDI 09-APR-81
;
;		PB235 -- ADDITION OF REQUEST QUEUE OPTIMIZATION SUPPORT.
;
;	P. J. BEZEREDI 06-MAY-81
;
;		PB242 -- ADD SUPPORT FOR RTEM AND CLEANUP A BIT.
;
; RL11/RL01 DISK DRIVER
;
;
.MCALL	HWDDF$,PKTDF$
	HWDDF$			;DEFINE HARDWARE REGISTERS
	PKTDF$			;DEFINE I/O PACKET OFFSETS
;
;****************
;
; EQUATED SYMBOLS
;
RETRY=	^D<8>			;CONTROLLER ERROR RETRY COUNT
RLCNT=	^D<7>			;NUMBER OF REGISTERS TO LOG ON ERROR	; PB228
RLBPT=	^D<512*20>		;BYTES PER RL01 SURFACE			;**-1
RLSPU=	^D<15>			;TIME FOR RL01 TO SPIN UP
LD$DQ=0
;
;****************
;
; RL11 DEVICE REGISTER OFFSETS
;
RLCS=	0			;CONTROL STATUS REGISTER
RLBA=	2			;BUS ADDRESS REGISTER
RLDA=	4			;DISK ADDRESS REGISTER
RLMP=	6			;MULTI-PURPOSE REGISTER
RLBAE=	10			;BUS ADDRESS EXTENSION REGISTER		; PB228
;
;****************
;
; RLCS BIT ASSIGNMENTS
;
ERR=	100000			;COMPOSITE ERROR
DE=	040000			;DRIVE ERROR
NXM=	020000			;NON-EXISTANT MEMORY
DLT=	010000			;DATA LATE
HNF=	010000			;HEADER NOT FOUND
DCK=	004000			;DATA CHECK ERROR
HCRC=	004000			;HEADER CRC ERROR
OPI=	002000			;OPERATION INCOMPLETE
A17=	000040			;EXTENDED ADDRESS BIT 17		; PB228
A16=	000020			;EXTENDED ADDRESS BIT 16		; PB228
DRDY=	1			;DRIVE READY
WCHK=	2			;WRITE CHECK FUNCTION
WRITE=	2			;WRITE OFFSET
GSTS=	4			;GET DRIVE STATUS FUNCTION
SEEK=	6			;SEEK FUNCTION
RDH=	10			;READ HEADERS FUNCTION
READ=	14			;READ DATA FUNCTION
IE=	100			;INTERRUPT ENABLE
CRDY=	200			;CONTROLLER READY
;
;****************
;
; RLDA STATUS CODES
;
MRK=	1			;MARKER BIT
STS=	2			;GET STATUS BIT
SN=	4			;SIGN BIT FOR SEEK
RST=	10			;DRIVE RESET BIT
HS=	20			;HEAD SELECT BIT FOR DIFFERENCE
REV=	200!MRK			;REVERSE SEEK DIFFERENCE WORD
;
;****************
;
; RLMP GET STATUS BIT ASSIGNMENTS
;
WDE=	100000			;WRITE DATA ERROR
CHE=	040000			;CURRENT HEAD ERROR
WLS=	020000			;WRITE LOCK STATUS
SKTO=	010000			;SEEK TIMEOUT ERROR
SPD=	004000			;SPEED ERROR
WGE=	002000			;WRITE GATE ERROR
VC=	001000			;VOLUME CHECK
DSE=	000400			;DRIVE SELECT ERROR
DT=	000200			;DRIVE TYPE
HSS=	000100			;HEAD SELECT STATUS
CO=	000040			;COVER OPEN
HH=	000020			;HEADS HOME
BH=	000010			;BRUSHES HOME
SLM=	000005			;DRIVE IN SEEK-LINEAR MODE STATE
;
;****************
;
; LOCAL DATA
;
; CONTROLLER IMPURE DATA TABLES
; THESE ARE INDEXED BY THE CONTROLLER NUMBER
;
RTTBL:	.BLKW	R$$L11		;RETRY COUNT FOR CURRENT OPERATION
PRMSV:	.BLKW	R$$L11*6	;PARAMETER SAVE AREA FOR WRITE CHECK	; PB228
;									;**-1
;****************
;
;DRIVER DISPATCH TABLE
;
	DDT$	DQ,R$$L11,NEW=Y,OPT=Y  ;GENERATE DISPATCH TABLE		; PB228
;
;****************
;
;+
; **-DLINI-RL11/RL01 DISK CONTROLLER INITIATOR
;
; THIS ROUTINE IS ENTERED FROM THE QUEUE I/O DIRECTIVE WHEN AN I/O
; REQUEST IS QUEUED AND AT THE END OF A PREVIOUS I/O OPERATION TO
; PROPAGATE THE EXECUTION OF THE DRIVER.  IF THE SPECIFIED CONTROLLER
; IS NOT BUSY, THEN AN ATTEMPT IS MADE TO DEQUEUE THE NEXT I/O REQUEST.
; ELSE A RETURN TO THE CALLER IS EXECUTED.  IF THE DEQUEUE ATTEMPT
; IS SUCCESSFUL, THEN THE NEXT I/O OPERATION IS INITIATED.  A RETURN
; TO THE CALLER IS THEN EXECUTED.
;
; INPUTS:
;	R5= ADRS OF THE UCB OF THE CONTROLLER TO BE INITIATED.
;
; OUTPUTS:
;	IF THE SPECIFIED CONTROLLER IS NOT BUSY AND AN I/O REQUEST IS
;	WAITING TO BE PROCESSED, THEN THE REQUEST IS DEQUEUED AND THE
;	DRIVER INITIATES THE REQUESTED I/O FUNCTION
;-
DQINI:	NOP
	NOP
	NOP
	CALL	$GTPKT
	BCC	X
	NOP
	RETURN
X:	NOP
;
; THE FOLLOWING ARGUMENTS ARE RETURNED BY $GTPKT:
;
;	R1= ADRS OF THE I/O REQUEST PACKET
;	R2= PHYSICAL UNIT NUMBER OF THE REQUESTED DRIVE
;	R3= CONTROLLER INDEX
;	R4= ADRS OF THE STATUS CONTROL BLOCK (SCB)
;	R5= ADRS OF THE UCB OF THE DRIVE TO BE INITIATED
;
; RL11/RL01 DISK CONTROLLER I/O REQUEST PACKET FORMAT:
;
;	WD. 00 -- I/O QUEUE THREAD WORD
;	WD. 01 -- REQUEST PRIORITY, EVENT FLAG NUMBER
;	WD. 02 -- ADRS OF THE TCB OF THE REQUESTOR TASK
;	WD. 03 -- POINTER TO 2ND LUN WORD IN REQUESTOR TASK HEADER
;	WD. 04 -- CONTENTS OF FIRST LUN WORD (UCB ADRS)
;	WD. 05 -- I/O FUNCTION CODE
;	WD. 06 -- VIRTUAL ADRS OF I/O STATUS BLOCK
;	WD. 07 -- RELOCATION BIAS OF I/O STATUS BLOCK
;	WD. 10 -- I/O STATUS BLOCK ADDRESS (DISPLACEMENT +140000)
;	WD. 11 -- VIRTUAL ADRS OF AST SERVICE ROUTINE
;	WD. 12 -- MEMORY EXTENSION BITS OF I/O TRANSFER
;	WD. 13 -- BUFFER ADRS OF I/O TRANSFER
;	WD. 14 -- NUMBER OF BYTES TO BE TRANSFERED
;	WD. 15 -- NOT USED.
;	WD. 16 -- LOW BYTE MUST BE ZERO AND HIGH BYTE IS NOT USED
;	WD. 17 -- LOW PART OF LOGICAL BLK NUMBER OF I/O REQUEST
;	WD. 20 -- RELOCATION BIAS OF DIAGNOSTIC REG. BLK. ELSE NOT USED
;	WD. 21 -- DIAGN. REG. BLOCK ADDRESS (DISPL.+140000) ELSE NOT USED
;
; DRIVER USAGE OF WORDS IN I/O PACKET:
;	I.PRM+6	 (WD. 15) - EXTENDED ADDRESS BITS			; PB228
;	I.PRM+10 (WD. 16) - CYLINDER # OR DESIRED DISK ADDRESS		; PB235
;	I.PRM+12 (WD. 17) - SECTOR/SURFACE # OR BYTES REMAINING TO XFER	; PB235
;									;**-3

	CALL	$RQCND		;REQUEST ACCESS TO CONTROLLER		; PB235
	MOV	S.PKT(R4),R1	;GET I/O PACKET ADDRESS			; PB235
	MOV	S.KRB(R4),R3	;GET KRB ADDRESS			; PB242
	MOVB	K.CON(R3),R3	;RETRIEVE CONTROLLER INDEX		; PB242
	MOV	#RETRY,RTTBL(R3);SET INITIAL RETRY COUNT		; PB242
	CALL	DLVV		;PROCESS VOLUME VALID FUNCTIONS		; PB242
	BIT	#FE.EXT,$FMASK	;IS THIS A 22-BIT SYSTEM?		; PB228
	BEQ	15$		;IF EQ NO				; PB228
	BIT	#DV.EXT,U.CW1(R5)  ;DOES THE RLBAE EXIST?		; PB228
	BEQ	10$		;IF EQ NO				; PB228
	MOVB	U.BUF+1(R5),R0	;GET EXTENDED ADDRESS BITS		; PB228
	MOV	R0,I.PRM+6(R1)	;SAVE THEM FOR LATER			; PB228
	ASH	#4,R0		;PUT THEM IN THE RIGHT PLACE		; PB228
	BIC	#^C<60>,R0	;JUST GET THE LOW 2 BITS		; PB228
	MOV	R0,U.BUF(R5)	;SAVE THEM				; PB228
	BR	15$		;					; PB228
10$:	CALL	$STMAP		;SETUP UNIBUS MAPPING REGISTERS		; PB228
15$:	MOVB	U.UNIT(R5),U.BUF+1(R5)  ;SET UNIT NUMBER		; PB228
	MOV	#IE.IFC&377,R0	;ASSUME ILLEGAL FUNCTION		;**-22
	BIS	#READ!IE,U.BUF(R5)  ;ASSUME READ LOGICAL FUNCTION
	CMPB	#IO.RLB/^D<256>,I.FCN+1(R1)  ;REALLY?
	BHIS	20$		;IF HIS FUNCTION IS LEGAL		; PB242
	CALLR	DLFIN		;FUNCTION IS ILLEGAL			; PB242
20$:	BEQ	25$		;IF EQ FUNCTION IS A READ		; PB242
	SUB	#WRITE,U.BUF(R5)  ;CONVERT TO WRITE LOGICAL FUNCTION	;**-3
25$:	MOV	I.PRM+12(R1),R0	;RETRIEVE SECTOR AND SURFACE		; PB235
	MOV	I.PRM+10(R1),R2	;RETRIEVE CYLINDER NUMBER		; PB235
	ASH	#7,R2		;PUT IT IN POSITION			; PB235
	BIS	R0,R2		;MERGE IN THE SECTOR AND SURFACE	; PB235
	MOV	R2,I.PRM+10(R1)	;SAVE DESIRED DISK ADDRESS		; PB235
	BIC	#^C<77>,R0	;ISOLATE SECTOR NUMBER			; PB235
	MOV	U.CNT(R5),I.PRM+12(R1)  ;ASSUME ONLY ONE XFER NEEDED	; PB235
	MOV	#^D<40>,R2	;SET SECTORS PER SURFACE		; PB235
	SUB	R0,R2		;CALCULATE SECTORS LEFT ON SURFACE	; PB235
	SWAB	R2		;GET BYTES LEFT ON SURFACE		; PB235
	CMP	U.CNT(R5),R2	;ARE ADDITIONAL TRANSFERS REQUIRED?	; PB235
	BLOS	30$		;IF LOS NO				; PB235
	MOV	R2,U.CNT(R5)	;SET BYTE COUNT FOR FIRST TRANSFER	; PB228
30$:	MOV	S.KRB(R4),R3	;GET KRB ADDRESS			; PB235
	MOVB	K.CON(R3),R3	;RETRIEVE CONTROLLER INDEX		; PB235
	MUL	#6,R3		;FORM AN INDEX INTO PARAMETER SAVE AREA	; PB235
	ADD	#PRMSV,R3	;POINT TO THIS ENTRY			; PB235
	MOV	U.BUF(R5),(R3)+	;SAVE INITIAL PARAMETERS		; PB235
	MOV	U.BUF+2(R5),(R3)+  ;...					; PB235
	MOV	U.CNT(R5),(R3)+	;...					; PB235
	MOV	I.PRM+10(R1),(R3)+  ;...				; PB235
	MOV	I.PRM+12(R1),(R3)+  ;...				; PB235
	MOV	I.PRM+6(R1),(R3)+  ;...					; PB228
									;**-37
;+
; THIS SECTION WILL INITIATE THE OPERATION
;-

DLINIO:	BIT	#FE.EXT,$FMASK	;IS THIS A 22-BIT SYSTEM?		; PB228
	BEQ	5$		;IF EQ NO				; PB228
	BIT	#DV.EXT,U.CW1(R5)  ;DOES THE RLBAE EXIST?		; PB228
	BNE	5$		;IF NE YES				; PB228
	CALL	$MPUBM		;MAP UNIBUS TO TRANSFER			; PB228
5$:	MOV	@S.KRB(R4),R2	;RETREIVE CSR ADDRESS			; PB228
	MOV	S.PKT(R4),R3	;GET ADDRESS OF I/O PACKET		;**-11
	CLRB	U.CW2+1(R5)	;CLEAR DRIVE FLAGS			; PB242
	CALL	DLGST		;GET DRIVE STATUS			; PB242
	MOV	RLMP(R2),R1	;GET THE STATUS INFO			;**-4
	BIC	#WLS!DT!HSS,R1	;REMOVE IRRELEVANT BITS
	BIT	#DRDY,(R2)	;IS THE DRIVE READY?
	BEQ	20$		;IF EQ NO				; PB242
	BITB	#US.VV,U.STS(R5);IS SOFTWARE VOLUME VALID SET?		; PB242
	BEQ	10$		;IF EQ NO				; PB242
	BIT	#VC,R1		;IS VOLUME CHECK SET?			; PB242
	BNE	25$		;IF NE YES, ERROR			; PB242
10$:	BIC	#VC,R1		;IGNORE VC BIT				; PB242
	CMP	#HH!BH!SLM,R1	;HEADS, BRUSHES AND STATE OK?		;**-1
	BEQ	30$		;IF EQ YES				; PB242
20$:	BITB	#US.SPU,U.STS(R5)  ;IS THE DRIVE SPINNING UP?		; PB242
	BNE	DLPWF1		;IF NE YES, WAIT FOR IT TO SPIN UP	; PB242
	CALL	DLDVER		;LOG DRIVE NOT READY ERROR		;**-3
25$:	MOV	#IE.DNR&377,R0	;SET RETURN ERROR CODE			; PB242
	CALLR	DLFIN		;EXIT FATAL				; PB242
30$:	BICB	#US.SPU,U.STS(R5)  ;RESET DRIVE SPINNING UP		; PB242
	CALL	DLRST		;RESET DRIVE ERRORS			; PB242
	MOV	I.PRM+10(R3),R0	;RETREIVE STARTING DISK ADDRESS		;**-3
	CALL	DLDIFF		;CALCULATE DIFFERENCE WORD
DLGO:	BEQ	40$		;IF EQ NO SEEK IS NECESSARY		; PB242
	MOV	#SEEK,R1	;GET CODE FOR SEEK FUNCTION		;**-1
	CALL	DLXCT		;EXECUTE THE SEEK
	BMI	DLEROR		;IF MI ERROR DURING SEEK FUNCTION	; PB242
40$:	MOVB	S.ITM(R4),S.CTM(R4)  ;SET TIMEOUT COUNT			; PB228
	BIT	#DV.EXT,U.CW1(R5)  ;DOES THE RLBAE EXIST?		; PB228
	BEQ	45$		;IF EQ NO				; PB228
	MOV	I.PRM+6(R3),RLBAE(R2)  ;LOAD EXTENDED ADDRESS BITS	; PB228
45$:	ADD	#RLMP,R2	;POINT TO RLMP				; PB228
	MOV	U.CNT(R5),R1	;GET BYTE COUNT				; PB228
	ROR	R1		;MAKE IT A WORD COUNT			;**-3
	NEG	R1		;ALSO NEGATIVE
	MOV	R1,(R2)		;LOAD WORD COUNT
	MOV	I.PRM+10(R3),-(R2)  ;LOAD STARTING DISK ADDRESS
	MOV	U.BUF+2(R5),-(R2)   ;LOAD BUS ADDRESS
	CALL	$BMSET		;SET I/O ACTIVE BIT IN MAP
	MOV	U.BUF(R5),-(R2)	;;;LOAD FUNCTION AND GO

;+
; CANCEL I/O OPERATION IS A NOP FOR FILE STRUCTURED DEVICES.
;-

DQCAN:	RETURN			;;;NOP FOR RL11

;+
; POWERFAIL IS HANDLED VIA THE DEVICE TIMEOUT FACILITY AND
; CAUSES NO IMMEDIATE ACTION ON THE UNIT.  THE CURRENT TIMEOUT
; COUNT IS EXTENDED SO THAT IF THE UNIT WAS BUSY IT WILL HAVE
; SUFFICIENT TIME TO SPIN BACK UP.  THE NEXT I/O REQUEST TO ANY
; UNIT WILL BE SUSPENDED FOR AT LEAST THE EXTENDED TIMEOUT UNLESS
; THE UNIT IS ALREADY READY.
;-

DQPWF:	TSTB	S.STS(R4)	;IS DRIVE CURRENTLY BUSY?
	BEQ	DLPWF2		;IF EQ NO				; PB242
	MOVB	#4,S.STS(R4)	;ALLOW FOR A FULL MINUTE TO SPIN UP	;**-1
DLPWF1:	MOVB	#RLSPU,S.CTM(R4);EXTEND TIMEOUT FOR UNIT		; PB242
DLPWF2:	BISB	#US.SPU,U.STS(R5)  ;SET UNIT SPINNING UP		; PB242
	RETURN			;					;**-2

;+
; **-$DLINT-RL11/RL01 DISK CONTROLLER
;	INTERRUPT AND ERROR SERVICE ROUTINES
;-
	INTSE$	DQ,PR5,R$$L11	;;;SAVE REGISTERS AND SET PRIORITY
	CALL	$FORK		;;;CREATE A SYSTEM PROCESS
	MOV	U.SCB(R5),R4	;RETRIEVE SCB ADDRESS			; PB232
	TSTB	U.CW2+1(R5)	;REVERSE SEEK IN PROGRESS?		; PB242
	BMI	DLINIO		;IF MI YES				; PB242
	MOV	@S.KRB(R4),R2	;RETRIEVE CSR ADDRESS			; PB235
	MOV	#IS.SUC&377,R0	;ASSUME SUCCESSFUL OPERATION		;**-5
	MOV	S.PKT(R4),R3	;RETREIVE I/O PACKET ADDRESS
	MOV	(R2),R1		;GET CONTENTS OF RLCS
	BMI	DLEROR		;IF MI AN ERROR OCCURRED		; PB228
	SUB	U.CNT(R5),I.PRM+12(R3)  ;GET BYTES LEFT TO TRANSFER	; PB228
	BEQ	DLPASS		;IF EQ NONE LEFT			; PB228
	MOV	I.PRM+12(R3),U.CNT(R5)  ;ASSUME LAST TRANSFER COMING	; PB228
	CMP	I.PRM+12(R3),#RLBPT  ;IS THIS THE LAST TRANSFER?	; PB228
	BLOS	10$		;IF LOS YES				; PB228
	MOV	#RLBPT,U.CNT(R5);TRANSFER A WHOLE TRACKS WORTH		; PB228
10$:	BIC	#CRDY,R1	;CLEAR CRDY TO START FUNCTION		; PB228
	MOV	R1,U.BUF(R5)	;SAVE CURRENT FUNCTION AND ADDRESS BITS	;**-8
	MOV	RLBA(R2),U.BUF+2(R5)  ;SAVE CURRENT BUS ADDRESS
	BIT	#DV.EXT,U.CW1(R5)  ;DOES THE RLBAE EXIST?		; PB228
	BEQ	20$		;IF EQ NO				; PB228
	MOV	RLBAE(R2),I.PRM+6(R3)  ;SAVE EXTENDED ADDRESS BITS	; PB228
20$:	MOV	I.PRM+10(R3),R0	;GET INITIAL DISK ADDRESS		; PB228
	MOV	R0,R1		;COPY DISK ADDRESS			;**-1
	BIS	#77,R0		;UPDATE CYLINDER AND SURFACE ...
	INC	R0		;... LEAVING SECTOR BITS ZERO
	MOV	R0,I.PRM+10(R3)	;SAVE NEW DISK ADDRESS
	CALL	DLDIF0		;CALCULATE MID-TRANSFER DIFFERENCE
	CALLR	DLGO		;GO DO THE OPERATION			; PB242
									; PB242
DLEROR:	BIT	#DRDY,R1	;IS THE DRIVE READY?			; PB242
	BNE	DLERR		;IF NE YES				; PB242
	MOVB	S.ITM(R4),S.CTM(R4)  ;WAIT FOR DRIVE TO QUIESCE		; PB242
	MOVB	#1,U.CW2+1(R5)	;FLAG SETTLE DOWN IN PROGRESS		; PB242
	RETURN			;					;**-6

DLERR:	MOV	(R2),R1		;RETRIEVE CONTENTS OF RLCS		; PB242
	BITB	#IQ.UMD,I.FCN(R3)  ;DIAGNOSTIC FUNCTION?		;**-1
	BNE	DLPASS		;IF NE YES, GO PASS REGISTERS		; PB242
	MOV	R1,-(SP)	;SAVE RLCS CONTENTS			;**-1
	CALL	DLDVER		;LOG DEVICE ERROR
	MOV	(SP),R1		;RETRIEVE CONTENTS OF RLCS		; PB144
	MOV	#IE.BBE&377,R0	;ASSUME BAD BLOCK ERROR			; PB144
	COM	(SP)		;TOGGLE THE BITS			; PB144
	BIT	#HCRC!OPI,(SP)+	;BAD BLOCK ERROR?			; PB144
	BEQ	DLFIN		;IF EQ YES				; PB144
	MOV	#IE.VER&377,R0	;ASSUME UNRECOVERABLE ERROR		;**-1
	BIT	#NXM,R1		;NON-EXISTANT MEMORY?
	BNE	DLFIN		;IF NE YES				; PB242
	BIT	#DE,R1		;DRIVE PROBLEMS?			;**-1
	BEQ	50$		;IF EQ NO				; PB242
	CALL	DLGST		;EXECUTE GET DRIVE STATUS FUNCTION	;**-1
	BIT	#WGE,RLMP(R2)	;WRITE GATE ERROR?
	BEQ	DLFIN		;IF EQ NO				; PB242
	BIT	#WLS,RLMP(R2)	;IS THE DRIVE WRITE LOCKED?		;**-1
	BEQ	DLRTY		;IF EQ NO				; PB242
	MOV	#IE.WLK&377,R0	;SET WRITE LOCK ERROR CODE		;**-1
	BR	DLFIN		;					; PB242
50$:	BIT	#10,U.BUF(R5)	;WRITE CHECK FUNCTION?			; PB242
	BNE	DLRTY		;IF NE NO				; PB242
	BIT	#OPI,R1		;OPERATION INCOMPLETE?			;**-3
	BNE	DLRTY		;IF NE YES				; PB242
	BIT	#DCK,R1		;WRITE CHECK ERROR?			;**-1
	BEQ	DLRTY		;IF EQ NO				; PB242
	MOV	#IE.WCK&377,R0	;YES, SET WRITE CHECK ERROR CODE	;**-1
DLRTY:	MOV	S.PKT(R4),R1	;RETRIEVE I/O PACKET ADDRESS		; PB242
	BITB	#IQ.X,I.FCN(R1)	;INHIBIT RETRIES?			;**-1
	BNE	DLFIN		;IF NE YES				; PB242
	MOV	S.KRB(R4),R3	;RETRIEVE KRB ADDRESS			; PB242
	MOVB	K.CON(R3),R3	;GET CONTROLLER INDEX			; PB242
	DECB	RTTBL(R3)	;ANY MORE RETRIES LEFT?			;**-1
	BLE	DLFIN		;IF LE NO				; PB242
DLIO:	CALL	DLRST		;RESET DRIVE ERRORS			; PB242
	JMP	DLINIO		;RETRY ENTIRE OPERATION			; PB242
									;**-2
DLPASS:	BITB	#IQ.UMD,I.FCN(R3)  ;DIAGNOSTIC FUNCTION?		; PB242
	BEQ	10$		;IF EQ NO				; PB242
	MOV	I.PRM+14(R3),KISAR6  ;SET BUFFER RELOCATION BIAS	;**-2
	MOV	I.PRM+16(R3),R3	;GET REGISTER BUFFER ADDRESS
	CALL	REGPAS		;MOVE REGISTERS INTO BUFFER
	BR	DLFIN		;EXIT					; PB242
10$:	BITB	#IO.WLC&377,I.FCN(R3)  ;WRITE WITH WRITE CHECK?		; PB242
	BNE	20$		;IF NE YES				; PB242
	BITB	#US.WCK,U.STS(R5)  ;WRITE CHECK ENABLED?		;**-3
	BEQ	DLFIN		;IF EQ NO				; PB242
20$:	MOV	U.BUF(R5),R1	;GET CURRENT FUNCTION CODE		; PB242
	BIT	#WCHK,R1	;WRITE OR WRITE CHECK FUNCTION?		;**-2
	BEQ	DLFIN		;IF EQ NO				; PB242
	BIT	#10,R1		;WAS FUNCTION WRITE CHECK?		;**-1
	BEQ	DLFIN		;IF EQ YES				; PB242
	MOV	S.KRB(R4),R1	;GET KRB ADDRESS			; PB235
	MOVB	K.CON(R1),R1	;RETRIEVE CONTROLLER INDEX		; PB235
	MOV	#RETRY,RTTBL(R1);RESET RETRY COUNT			;**-2
	MUL	#6,R1		;FORM AN INDEX INTO PARAMETER SAVE AREA	; RP026
	ADD	#PRMSV,R1	;...					;**-1
	MOV	(R1)+,U.BUF(R5)	;RESTORE STARTING PARAMETERS
	MOV	(R1)+,U.BUF+2(R5)  ;...
	MOV	(R1)+,U.CNT(R5)	;...
	MOV	(R1)+,I.PRM+10(R3)  ;...
	MOV	(R1)+,I.PRM+12(R3)  ;...
	MOV	(R1)+,I.PRM+6(R3)  ;...					; PB228
	BR	DLIO		;START THE WRITE CHECK			; PB242
									; PB242
DLFIN:	MOV	S.PKT(R4),R2	;GET ADDRESS OF I/O PACKET		; PB242
	MOV	I.PRM+4(R2),R1	;GET TOTAL TRANSFER SIZE		;**-4
	SUB	I.PRM+12(R2),R1	;CALCULATE BYTES TRANSFERED		; PB228
	MOV	S.KRB(R4),R3	;GET KRB ADDRESS			; PB235
	MOVB	K.CON(R3),R3	;RETRIEVE CONTROLLER INDEX		; PB235
	MOVB	RTTBL(R3),R2	;GET FINAL RETRY COUNT			;**-2
	BIS	#RETRY*^D<256>,R2  ;MERGE STARTING RETRY COUNT
	CALL	$RLCN		;RELEASE THE CONTROLLER			; PB235
	CALL	$IODON		;FINISH I/O OPERATION
	JMP	DQINI		;PROCESS NEXT REQUEST

;+
; **-DLOUT-RL11/RL01 DISK CONTROLLER
;	DEVICE TIMEOUT ROUTINE
;
; DEVICE TIMEOUT RESULTS IN THE OPERATION BEING REPEATED.
; TIMEOUTS ARE USUALLY CAUSED BY A POWER FAILURE BUT MAY ALSO
; BE THE RESULT OF A HARDWARE MALFUNCTION.
;-

DQOUT:	MOV	S.PKT(R4),R3	;;;RETREIVE I/O PACKET ADDRESS
	BITB	#US.SPU,U.STS(R5)  ;;;IS DRIVE SPINNING UP?
	BEQ	20$		;;;IF EQ NO				; PB242
	DECB	S.STS(R4)	;;;HAVE WE WAITED A MINUTE YET?		;**-1
	BNE	10$		;;;IF NE NO				; PB242
	INCB	S.STS(R4)	;;;LEAVE CONTROLLER BUSY		;**-1
	BR	30$		;;;LOG DEVICE TIMEOUT			; PB242
10$:	MTPS	#0		;;;ALLOW INTERRUPTS			; PB242
	BR	DLIO		;RETRY ENTIRE OPERATION			; PB242
20$:	ASRB	U.CW2+1(R5)	;;;IS DRIVE SETTLING DOWN?		; PB242
	BNE	30$		;;;IF NE NO				; PB242
	MTPS	#0		;;;YES, ALLOW INTERUPTS			;**-5
	JMP	DLERR		;PROCESS THE ERROR			; PB242
30$:	MTPS	#0		;;;ALLOW INTERRUPTS			; PB242
	BITB	#IQ.UMD,I.FCN(R3)  ;DIAGNOSTIC FUNCTION?		;**-2
	BNE	DLPASS		;IF NE YES, GO PASS REGISTERS		; PB242
	CALL	DLDTER		;LOG DEVICE TIMEOUT			;**-1
	MOV	#IE.DNR&377,R0	;SET DEVICE NOT READY			;**-1
	JMP	DLRTY		;RETRY OPERATION			; PB242
									;**-6
;+
; **-DLXCT,DLGST,DLRST-RL11/RL01 DISK CONTROLLER
;	FUNCTION EXECUTION ROUTINES
;
; THIS ROUTINE WILL EXECUTE A GET DRIVE STATUS OR ANY
; NON-INTERRUPTABLE FUNCTION AND WAIT FOR ITS COMPLETION.
;
; INPUTS:
;	R1 = FUNCTION CODE
;	R2 = CSR ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUTS:
;	R1 = CONTENTS OF RLCS (TESTED)
;	FUNCTION EXECUTED
;-

DLRST:	MOV	#RST!STS!MRK,RLDA(R2)  ;SET MESSAGE CODES IN RLDA
	CALL	DLDST		;DO THE DRIVE RESET FIRST		; PB242
DLGST:	MOV	#STS!MRK,RLDA(R2)  ;SET MESSAGE CODES IN RLDA		;**-1
DLDST:	MOV	#GSTS,R1	;SET GET STATUS FUNCTION		; PB242
DLXCT:	MOV	R1,-(SP)	;SAVE FUNCTION CODE			;**-1
	MOVB	U.UNIT(R5),1(SP);MERGE CURRENT DRIVE BITS
	MOV	(SP)+,(R2)	;LOAD RLCS
10$:	BIT	#100200,(R2)	;FUNCTION COMPLETE OR ERROR?		; PB242
	BEQ	10$		;IF EQ NO				; PB242
	MOV	(R2),R1		;SAVE RLCS AND TEST FOR ERRORS		;**-2
	RETURN			;

;+
; **-DLDIFF-RL11/RL01 DISK CONTROLLER
;	CYLINDER ADDRESS DIFFERENCE CALCULATOR
;
; THIS SUBROUTINE CALCULATES THE DIFFERENCE WORD USED IN THE
; SEEK OPERATION.  IF A HEADER CANNOT BE READ AFTER 16. RETRIES,
; AN ERROR WILL BE LOGGED AND A ONE CYLINDER REVERSE SEEK WILL BE
; ISSUED.  THE SEEK IS FOLLOWED BY A READ HEADERS TO CAUSE AN
; INTERRUPT.
;
; INPUTS:
;	R0 = DESIRED DISK ADDRESS
;									;**-1
; OUTPUTS:
;	R1 = DIFFERENCE WORD
;	RLDA = LOADED WITH DIFFERENCE WORD
;	IF EQ NO SEEK IS NECESSARY					;**-1
;-

DLDIFF:	MOV	#RETRY*2,-(SP)	;SET READ HEADER RETRY COUNT
10$:	MOV	#RDH,R1		;CODE FOR READ HEADERS FUNCTION		; PB242
	CALL	DLXCT		;EXECUTE THE FUNCTION			;**-1
	BPL	20$		;IF PL FUNCTION EXECUTED OK		; PB242
	DEC	(SP)		;ANY RETRIES LEFT?			;**-1
	BGT	10$		;IF GT YES				; PB242
	CMP	(SP)+,(SP)+	;REMOVE RETRY COUNT AND CALLERS ADDRESS	;**-1
	CALL	DLDVER		;LOG HEADER ERROR
	CALL	DLRST		;RESET DRIVE
	MOV	#REV,RLDA(R2)	;LOAD REVERSE SEEK DIFFERENCE WORD
	MOV	#SEEK,R1	;GET CODE FOR SEEK FUNCTION
	MOV	#IE.VER&377,R0	;ASSUME THE SEEK WILL FAIL		; PB242
	CALL	DLXCT		;EXECUTE THE SEEK
	BMI	DLFIN		;IF MI WE FAILED			; PB242
	BIC	#377,R1		;CLEAR OUT FUNCTION BITS		;**-1
	BIS	#IE!RDH,R1	;LOAD CODES FOR READ HEADER
	MOVB	#200,U.CW2+1(R5);INDICATE REVERSE SEEK IN PROGRESS	; PB242
	MOVB	S.ITM(R4),S.CTM(R4)  ;SET DEVICE TIMEOUT COUNTER	;**-1
	MOV	R1,(R2)		;LOAD FUNCTION AND GO
	RETURN			;WAIT FOR THE INTERRUPT
20$:	TST	(SP)+		;REMOVE RETRY COUNT			; PB242
	MOV	RLMP(R2),R1	;RETREIVE HEADER WORD			;**-1
DLDIF0:	BIC	#77,R0		;MASK OUT SECTOR BITS			; PB228
	BIC	#77,R1		;...					;**-2
	CMP	R0,R1		;DO WE NEED TO DO A SEEK?
	BEQ	40$		;IF EQ NO				; PB242
	MOV	R0,-(SP)	;SAVE DESIRED DISK ADDRESS		;**-1
	BIC	#^C<100>,(SP)	;ISOLATE SURFACE BIT
	ASR	(SP)		;PUT INTO THE PROPER POSITION
	ASR	(SP)		;...
	BIC	#100,R0		;REMOVE SURFACE BIT
	BIC	#100,R1		;...
	SUB	R0,R1		;SUBTRACT DESIRED FROM ACTUAL
;	BEQ	30$		;IF EQ ONLY CHANGE SURFACE		; PB242
	BCC	30$		;IF CC ACTUAL .GE. DESIRED		; PB242
	NEG	R1		;ACTUAL < DESIRED, MAKE POSITIVE DIFFERE;**-2
	BIS	#SN,R1		;SET SIGN FOR MOVE TO CENTER OF DISK
30$:	INC	R1		;SET MARKER BIT				; PB242
	BIS	(SP)+,R1	;MERGE IN SURFACE BIT			;**-1
	MOV	R1,RLDA(R2)	;LOAD DIFFERENCE WORD
40$:	RETURN			;					; PB242
									;**-2

;+
; **-DLDXXX-RL11/RL01 DISK CONTROLLER
;	ERROR LOGGING ROUTINES
;
; THIS ROUTINE IS CALLED WHENEVER A DEVICE ERROR OR DEVICE TIMEOUT
; OCCURS.  A CORE BLOCK THE SIZE OF THE REGISTER BUFFER IS ALLOCATED
; AND THE UNIBUS REGISTERS ALONG WITH THE DRIVE STATUS INFORMATION
; ARE TRANSFERED INTO THE CORE BLOCK AND THE APPROPRIATE EXECUTIVE
; ERROR LOGGING ROUTINE IS CALLED.  FINALLY, THE CORE BLOCK IS
; DEALLOCATED AND THE CSR AND CONTROLLER INDEX ARE RESTORED.
;
; IF FOR ANY REASON THE CORE BLOCK CANNOT BE ALLOCATED THEN THE
; EXECUTIVE ERROR LOGGING ROUTINE WILL NOT BE CALLED AND THE ERROR
; SEQUENCE NUMBER WILL BE UPDATED TO INDICATE THAT A MISSED ERROR
; CONDITION OCCURRED.
;
; INPUTS:
;	R2 = CSR ADDRESS
;	R4 = SCB ADDRESS
;
; OUTPUTS:
;	R0, R1 ARE DESTROYED						; PB242
;	R3 = CONTROLLER INDEX						;**-1
;-

	.ENABL	LSB							; PB242
DLDVER:	MOV	#$DVERR,-(SP)	;ADDRESS OF EXEC ERROR ROUTINE		; PB242
	BR	10$		;					; PB242
DLDTER:	MOV	#$DTOER,-(SP)	;ADDRESS OF EXEC TIMEOUT ROUTINE	; PB242
10$:	TST	(SP)+							; PB242
	BR	30$							; PB242
	MOV	#RLCNT*2,R1	;GET NUMBER OF BYTES TO ALLOCATE	; PB242
	CALL	$ALOCB		;ALLOCATE A CORE BLOCK			;**-6
	BCC	20$		;IF CC BLOCK WAS ALLOCATED		; PB242
	INC	$ERRSQ		;INDICATE A MISSED ERROR CONDITION	;**-1
	CMP	(SP)+,#$DTOER	;ALLOCATION FAILURE, TIMEOUT IN PROGRESS?
	BNE	30$		;IF NE NO				; PB235
	MOV	@S.KRB(R4),R2	;;;RETRIEVE CSR ADDRESS			; PB235
	BIC	#IE,(R2)	;;;CLEAR INTERRUPT ENABLE		; PB235
	MTPS	#0		;;;ALLOW INTERRUPTS			;**-2
	BR	30$		;DON'T LOG ERROR IF ALLOCATION FAILURE	; PB242
20$:	MOV	R0,R3		;SET POINTER TO CORE BLOCK		; PB242
	MOV	@S.KRB(R4),R2	;GET REAL CSR ADDRESS			; PB235
	CALL	REGPAS		;MOVE REGISTERS INTO CORE BLOCK		;**-3
	MOV	R0,R2		;COPY CORE BLOCK ADDRESS
	CALL	@(SP)+		;CALL EXEC ERROR LOGGING ROUTINE
	MOV	R2,R0		;GET BACK CORE BLOCK ADDDRESS
	MOV	#RLCNT*2,R1	;GET NUMBER OF BYTES TO DEALLOCATE
	CALL	$DEACB		;DEALLOCATE THE CORE BLOCK
30$:	MOV	S.KRB(R4),R3	;GET KRB ADDRESS			; PB235
	MOV	(R3),R2		;RETRIEVE CSR ADDRESS			; PB235
	MOVB	K.CON(R3),R3	;RETRIEVE CONTROLLER INDEX		; PB235
	RETURN								;**-3
	.DSABL	LSB							; PB242

;+
; MOVE THE CONTROLLER/DRIVE REGISTERS INTO THE SPECIFIED BUFFER.
;
; INPUTS:
;	R2 = CSR ADDRESS
;	R3 = BUFFER ADDRESS
;-

REGPAS:	MOV	(R2),(R3)+	;MOVE RLCS
	MOV	RLBA(R2),(R3)+	;MOVE RLBA
	MOV	RLDA(R2),(R3)+	;MOVE RLDA
	MOV	RLMP(R2),(R3)+	;MOVE RLMP
	CLR	(R3)+		;ASSUME NO RLBAE			; PB228
	BIT	#DV.EXT,U.CW1(R5)  ;DOES THE RLBAE EXIST?		; PB228
	BEQ	10$		;IF EQ NO				; PB228
	MOV	RLBAE(R2),-2(R3);MOVE RLBAE				; PB228
10$:	CLR	(R3)+		;EXTRA WORD IS BLANK			; PB228
	CALL	DLGST		;EXECUTE GET DRIVE STATUS FUNCTION	; PB228
	MOV	RLMP(R2),(R3)	;SAVE DRIVE STATUS			;**-1
	RETURN			;
									; PB242
;+									; PB242
; **-DLVV-PROCESS VOLUME VALID FUNCTIONS				; PB242
;									; PB242
; THIS ROUTINE WILL VALIDATE VOLUME VALID AND HANDLE DEVICE		; PB242
; SPECIFIC VOLUME VALID AND SIZING FUNCTIONS.				; PB242
;									; PB242
; INPUTS:								; PB242
;	R1 = I/O PACKET ADDRESS						; PB242
;	R4 = SCB ADDRESS						; PB242
;	R5 = UCB ADDRESS						; PB242
;									; PB242
; OUTPUTS:								; PB242
;	IF THIS IS A TRANSFER FUNCTION ONLY R0 IS DESTROYED.		; PB242
;	IF THIS IS A VOLUME VALID FUNCTION, THE PROPER ACTION		; PB242
;	  IS TAKEN AND CONTROL IS TRANSFERED DIRECTLY TO THE		; PB242
;	  PROPER PLACE IN THE DRIVER.					; PB242
;-									; PB242
									; PB242
DLVV:	CALL	$VOLVD		;VALIDATE VOLUME VALID			; PB242
	BCS	20$		;IF CS WE FAILED			; PB242
	TST	R0		;IS THIS A TRANSFER FUNCTION?		; PB242
	BMI	30$		;IF MI YES				; PB242
	MOV	@S.KRB(R4),R2	;RETRIEVE CSR ADDRESS			; PB242
	MOV	R1,R3		;COPY I/O PACKET ADDRESS		; PB242
	CALL	DLRST		;RESET DRIVE AND GET STATUS		; PB242
	TST	I.PRM+2(R3)	;SIZE THE DISK?				; PB242
	BPL	10$		;IF PL NO				; PB242
	TST	(SP)+		;REMOVE RETURN				; PB242
	CALLR	DLPASS		;PASS REGISTERS AND EXIT		; PB242
10$:	BIT	#VV$SET,I.PRM+2(R3)  ;SET VOLUME VALID?			; PB242
	BEQ	25$		;IF EQ NO				; PB242
	MOV	RLMP(R2),R1	;GET THE STATUS INFORMATION		; PB242
	BIT	#DRDY,(R2)	;IS THE DRIVE READY?			; PB242
	BEQ	20$		;IF EQ NO				; PB242
	BIC	#WLS!DT!HSS,R1	;REMOVE IRRELEVANT BITS			; PB242
	CMP	#HH!BH!SLM,R1	;HEADS, BRUSHES AND STATE OK?		; PB242
	BEQ	25$		;IF EQ YES				; PB242
20$:	BICB	#US.VV,U.STS(R5);CLEAR SOFTWARE VOLUME VALID		; PB242
	MOV	#IE.DNR&377,R0	;SET DRIVE NOT READY			; PB242
25$:	TST	(SP)+		;REMOVE RETURN				; PB242
	CALLR	DLFIN		;FINISH UP				; PB242
30$:	RETURN			;					; PB242
									; PB235
;+									; PB235
; **-DLCHK-VALIDATE AND CONVERT THE LBN					; PB235
;									; PB235
; THIS ROUTINE IS CALLED FROM $DRQRQ TO DO LBN PROCESSING		; PB235
; FOR DEVICES WHICH SUPPORT QUEUE OPTIMIZATION.  IF BLKC2		; PB235
; DETECTS AN ERROR IT WILL RETURN TO THE CORRECT PLACE IN		; PB235
; $DRQRQ AFTER CALLING $IOALT.						; PB235
;									; PB235
; INPUTS:								; PB235
;	R1 = I/O PACKET ADDRESS						; PB235
;	R4 = SCB ADDRESS						; PB235
;	R5 = UCB ADDRESS						; PB235
;									; PB235
; OUTPUTS:								; PB235
;	IF THE CHECKS SUCCEED, THEN THE LBN IN THE I/O PACKET		; PB235
;	IS REPLACED BY THE DISK ADDRESS.  R1 IS PRESERVED.		; PB235
;									; PB235
;	IF THE CHECKS FAIL, THE $IOALT IS ENTERED WITH A FINAL		; PB235
;	STATUS OF IE.BLK AND A RETURN TO THE CORRECT PLACE IN		; PB235
;	$DRQRQ IS EXECUTED.						; PB235
;									; PB235
;	R0, R2, AND R3 ARE DESTROYED.					; PB235
;									; PB235
; NOTE:	ALL FUNCTIONS PUT INTO THE DRIVER QUEUE ARRIVE HERE.		; PB235
;	THESE FUNCTIONS INCLUDE, IO.ATT, IO.DET, AND ACP FUNCTIONS.	; PB235
;-									; PB235
									; PB235
									; PB235
DQCHK:	CALL	$LEKAS		;CHECK FOR AN ACP FUNCTION		; PB235
	BCS	30$		;IF CS IT IS, LEAVE IT ALONE		; PB235
	CMPB	#IO.ATT/256.,I.FCN+1(R1)  ;IS THIS AN ATTACH?		; PB235
	BEQ	30$		;IF EQ YES, LEAVE IT ALONE		; PB235
	CMPB	#IO.DET/256.,I.FCN+1(R1)  ;IS THIS A DETACH?		; PB235
	BEQ	30$		;IF EQ YES, LEAVE IT ALONE		; PB235
	MOV	I.FCN(R1),-(SP)	;GET FUNCTION CODE			; PB235
	BIC	#7,(SP)		;REMOVE QUALIFIER BITS			; PB235
	CMP	#IO.STC,(SP)+	;IS IT A SET CHARACTERISTICS?		; PB235
	BEQ	30$		;IF EQ YES, LEAVE IT ALONE		; PB235
	MOV	I.PRM+12(R1),R0	;RETRIEVE STARTING BLOCK NUMBER		; PB235
	BITB	#IO.WPB&377,I.FCN(R1)  ;PHYSICAL BLOCK FUNCTION?	; PB235
	BNE	20$		;IF NE YES				; PB235
	CALL	$BLKC2		;CHECK LOGICAL BLOCK NUMBER		; PB235
	CMPB	#IO.WLB/256.,I.FCN+1(R3)  ;WRITE FUNCTION?		; PB235
	BNE	10$		;IF NE NO				; PB235
	BITB	#IO.WLT&377,I.FCN(R3)  ;WRITE LAST TRACK FUNCTION?	; PB235
	BNE	10$		;IF NE YES				; PB235
	MOV	R0,I.PRM+6(R3)	;SAVE STARTING BLOCK NUMBER		; PB235
	ADD	#20.,(R1)	;ADD 1 TRACKS WORTH OF BLOCKS		; PB235
	MOV	R3,R1		;COPY I/O PACKET ADDRESS		; PB235
	CALL	$BLKC2		;CHECK LOGICAL BLOCK NUMBER		; PB235
	MOV	I.PRM+6(R3),R0	;RESTORE ORIGINAL STARTING BLOCK NUMBER	; PB235
10$:	ASL	R0		;CONVERT BLOCKS TO SECTORS		; PB235
20$:	MOV	S.PKT(R4),R3	;RETRIEVE I/O PACKET ADDRESS		; PB235
	CLR	R2		;NO HIGH BITS				; PB235
	CALL	$CVLBN		;CONVERT LBN TO DISK ADDRESS		; PB235
	ASH	#6,R1		;POSITION SURFACE BIT			; PB235
	BIS	R1,R0		;MERGE SURFACE WITH SECTOR		; PB235
	MOV	R0,I.PRM+12(R3)	;SAVE SECTOR AND SURFACE ADDRESS	; PB235
	MOV	R2,I.PRM+10(R3)	;SAVE STARTING CYLINDER ADDRESS		; PB235
	MOV	R3,R1		;COPY I/O PACKET ADDRESS		; PB235
30$:	RETURN			;					; PB235
									; PB228
;+									; PB228
; **-DLKRB-CONTROLLER ONLINE/OFFLINE ROUTINE				; PB228
;									; PB228
; THIS ROUTINE WILL HANDLE RECONFIGURATION CALLS FOR ONLINE		; PB228
; CONTROLLER AND OFFLINE CONTROLLER FOR THE RL11, RLV11 AND RLV12.	; PB228
;									; PB228
; FOR ONLINE, IT WILL DETERMINE IF THE RLBAE REGISTER EXISTS AND IF	; PB228
; SO, IT WILL INSURE THAT THE ADDRESS BITS ARE REPLICATED IN THE	; PB228
; CSR.									; PB228
;									; PB228
; FOR OFFLINE, KS.EXT WILL BE CLEARED.					; PB228
;									; PB228
; INPUTS:								; PB228
;	R2 = KRB ADDRESS						; PB228
;	R3 = CTB ADDRESS						; PB228
;	C=1 IF OFFLINE REQUEST						; PB228
;	C=0 IF ONLINE REQUEST						; PB228
;									; PB228
; OUTPUTS:								; PB228
;	FOR ONLINE, KS.EXT WILL BE SET IF THE CONTROLLER HAS A		; PB228
;	VALID RLBAE.							; PB228
;	FOR OFFLINE, KS.EXT IS CLEARED.					; PB228
;-									; PB228
									; PB228
DQKRB:	BIC	#KS.EXT,K.STS(R2)  ;ASSUME NO RLBAE			; PB228
	BCS	20$		;IF CS OFFLINE REQUEST			; PB228
	BIT	#FE.EXT,$FMASK	;IS THIS A 22-BIT SYSTEM?		; PB228
	BEQ	20$		;IF EQ NO				; PB228
	CALL	$SGFIN		;TURN NXM'S INTO SET CARRY BITS		; PB228
	MOV	(R2),R4		;RETREIVE CSR ADDRESS			; PB228
	BIS	#A16!A17,(R4)	;SET EXTENDED ADDRESS BITS		; PB228
	CLR	RLBAE(R4)	;CLEAR RLBAE BITS			; PB228
	BCS	10$		;IF CS RLBAE DOES NOT EXIST		; PB228
	BIT	#A16!A17,(R4)	;DID THE ADDRESS BITS CLEAR?		; PB228
	BNE	10$		;IF NE NO				; PB228
	BIS	#KS.EXT,K.STS(R2)  ;YES, SET RLBAE PRESENT		; PB228
10$:	BIC	#A16!A17,(R4)	;RESET ADDRESS BITS			; PB228
20$:	RETURN			;					; PB228
									; PB228
;+									; PB228
; **-DLUCB-UNIT ONLINE/OFFLINE ROUTINE					; PB228
;									; PB228
; THIS ROUTINE WILL HANDLE RECONFIGURATION CALLS FOR ONLINE		; PB228
; UNIT AND OFFLINE UNIT FOR RL01 AND RL02 DRIVES.			; PB228
;									; PB228
; FOR ONLINE, IF KS.EXT IS SET THEN DV.EXT IS ALSO SET.  THIS		; PB228
; IS DONE TO ELIMINATE UNNECESSARY CODE TO RETREIVE THE KRB		; PB228
; ADDRESS.								; PB228
;									; PB228
; FOR OFFLINE, DV.EXT IS CLEARED.					; PB228
;									; PB228
; INPUTS:								; PB228
;	R3 = CONTROLLER INDEX						; PB228
;	R4 = SCB ADDRESS						; PB228
;	R5 = UCB ADDRESS						; PB228
;	C=1 IF ONLINE REQUEST						; PB228
;	C=0 IF OFFLINE REQUEST						; PB228
;									; PB228
; OUTPUTS:								; PB228
;	FOR ONLINE, DV.EXT IS SET IN THE UCB IF KS.EXT IS		; PB228
;	SET IN THE KRB.							; PB228
;	FOR OFFLINE, DV.EXT IS CLEARED.					; PB228
;-									; PB228
									; PB228
DQUCB:	BIC	#DV.EXT,U.CW1(R5)  ;ASSUME NO RLBAE			; PB228
	BCS	10$		;IF CS OFFLINE REQUEST			; PB228
	MOV	S.KRB(R4),R2	;RETREIVE KRB ADDRESS			; PB228
	BIT	#KS.EXT,K.STS(R2)  ;DOES THE RLBAE EXIST?		; PB228
	BEQ	10$		;IF EQ NO				; PB228
	BIS	#DV.EXT,U.CW1(R5)  ;YES, SET BIT IN UCB			; PB228
10$:	RETURN			;					; PB228
									;**-1
	.END